2019 Projects

LabelLab is an image analyzing and classification platform. The web application should allow users to upload batches of images and classify them with labels. It will also have the features to run classifications against a trained model. LabelLab also has a user project management component as well as an image analyzing component.

My goal will be to finish up the details and missing functionality of the Boost.Real library created during the previous GSoC and get it to review ready state.

I will work to find WebAssembly based solution for missing mediaRecorder API for browsers like Safari and Edge. By using native mp3 encoder that will be used in the browser with the help of Emscripten compiled javascript output.

Fake news is polarizing peoples and our society in an adverse way. Its effect can be seen more and more as people’s reach to social media and to the internet is been increasing. Fake news is not only creating communal hatred but also, polarizing general elections.

Click-bait waste a lot of productive time of people. These headlines are written in a very catchy manner such that people are tempted to click these links and they don’t contain any relevant information. So it is necessary to warn a user about click-bait.

This is a Chrome extension to detect Fake News and click-bait news on news websites and social media like Facebook and Twitter.

My proposal is based on enhancements that would incorporate real world use cases into the project and testing and maintainability that will bring consistency in contribution, make reviewing and testing thorough

The goal involves enhancing Image Sequencer and making it rich by incorporating:

1. More refined input options for coordinates(x,y) and color inputs.
2. Optimizing resize, fixing load-Preview to reduce load time and improve application performance.
3. Particle sizing and analysis using OpenCV.
4. Noise removal for targeting better image refinement.
5. Add Blur Radius functionality upon the existing blur module.
6. Adding Compositing module.
7. Improvise project maintainability and consistency. Add tests, documentation for new features added during coding period.

This project reviews some of the pretrained models that are available in other frameworks and projects like Keras and ONNX but currently unavailable in Tensorflow hub as a published module and proposes to export them to hub following all conventions. After porting to tensorflow hub the models will also be converted to tensorflow.js and released with guides and documentation.

Deploying a machine learning module using Swift for Tensorflow it to a mobile device, including building out necessary components of the Swift for TensorFlow and TFLite ecosystems.

Effects are a important and widely used feature of Pitivi and improving their UX will make Pitivi easier to use and lower its learning curve for newcomers. This will help in furthering Pitivi’s goal of “allowing everyone to express themselves through the art of film making”.

The objective is to build a web-based Honeypot project by identifying the emerging attacks against web applications and report them to the community, in order to facilitate protection against targeted attacks. With the help of ModSecurity, we lay HoneyTraps by adding more network ports that will accept HTTP request traffic.

Extend VolEsti (a c++ library with an R interface) by implementing randomized algorithms for convex optimization. First, there is a need to implement some more random walks so we can choose which to use with respect to our problem, e.g. ratio of dimensions / constraints. Such a choice is important, because the sampling is the bottleneck of the proposed algorithms, so it must be as efficient as possible. Second, use these sampling methods to solve convex optimization problems and the redundancy problem. I propose a variety of randomized algorithms, such as one that uses cutting planes and one that uses simulated annealing. In the end, I will provide support for linear programming, semidefinite programming and mixed integer linear programming. A good part of the project will be testing to provide empirical data, since some of these algorithms perform better in practice than predicted by theory.

Develop a simulator which will support all the features of SBML core specification

• Implement a code so that the simulator can pass testcases which require simulators to correctly handle mathematical equations (concentration vs. amount, function definitions, assignment rules etc.)
• Implement a code so that the simulator can pass testcases which require simulators to correctly handle discrete events.
• Implement a code so that the simulator can pass testcases which require simulators to correctly handle delayed differential equations.

Integrate the REST API that is being added to upstream Roundup to bugs.python.org (b.p.o). Develop the following list of tools and features that employ the REST API:

• Tools to easily generate random issues/messages, useful for testing
• Command-line interface to access the tracker
• Advanced statistics, graphs, leaderboards
• Real time filtering/ordering of issues
• Customizable dashboard
• Related issues suggestions
• Simpler integrations with other services (GitHub, IRC, etc.)

Create a hardware/software design will incorporate shift registers to allow BB.org hardware to communicate with hardware via a parallel, bi-directional bus. Create a software design that incorporates both a kernel driver to communicate with the parallel bus and a user space application/library using ioctl() calls to communicate with this kernel driver. Using the PRU to implement the low-level details of the bus.

Multivariate Analysis techniques are indispensable in the era of Big Data. However, a unified and user-friendly framework has been lacking to date. Individual packages allow for certain special cases handled by MoMA, but for advanced cases, no standard packaged solution is available. The MoMA package will provide the first unified toolbox for all forms of high-dimensional multivariate analysis in R or any other language. MoMA will empower statisticians and data scientists to flexibly find patterns that respect the specific structure of their data and allow for truly Modern Multivariate Analysis.

OpenWorm is an attempt to build a biophysical simulation of the model organism C. elegans via assimilation of published data from a range of sources. Publication of biological data is often weakly structured and has no standardised format making assimilation challenging. Currently PyOpenWorm acts as a quick data access layer for researchers to query C. elegans anatomy and physiology. It currently incorporates data from the primary literature, WormAtlas and WormBase. This project would aim to expand the data available for model validation and for query in PyOpenWorm. Expanding the data available would aid hypothesis generation in the C.elegans research community, by allowing fast access to past observations and by facilitating the generation of more robust models through model validation tests such as SciUnit. However, ultimately it could also be a poster child to inspire an increase in standardisation and statistical accountability in the publication of biological research as a whole.

The Project idea aims at integrating a Library to generate QR code within LibreOffice itself and add options to use the QR code in LO applications.

QR Code will be generated for text or URL, QR Code can also be generated even for special(UTF) characters, The generated image will be in SVG Format, Better Rendering Quality, Scalable, QR Code will be generated as an Image so it is handled easily line an Image.

This project is of type Improving an existing tool that includes cleaning up the existing codebase and adding the process injection support for Linux.

Fineract-CN-Mobile is an Android app for Digital Financial services that is built on top of FIneract-CN platform. It provides banking solutions for people around the world who are unbacked. This app is for field officers who go to their customers and help them with their financial services.

I would like to improve the app by implementing the feature that is mentioned below which would improve the user experience, functionality and overall aesthetics of the app.

1. Add Multiple account login and maintain session of the account.
2. Add Passcode feature to avoid the every time login.
3. Sync Adapter to sync clients and client data that is assigned to him.
4. Add Kotlin support in the app and initially change the retrofit models in Kotlin.
5. Add review screen in every new records creation form.
6. Edit Loan application feature if loan is not approved
7. Add new data views in different different pages like customer detail page according to API, same as in loan, deposit account details
8. Add feature to take high quality picture and compress with the same quality for uploading (Uploading feature already exist, student need to enhance picture quality)

My project is about creating a complet, reusable library for graphs including the layouting algorithms, in Pharo. The idea is to leave it open for multiple visualization engines to use.

I would like to work implementing missing features in nftables. My plan is to work on the following subtasks: extending stateful object infrastructure, allow deletion of set elements from ruleset and rework netfilter logging.

Another task that catches my attention is working on nftlb. I think my professional experience with load balancers and inverse proxies can be useful to develop this task successfully.

The coreboot project is automatically scanned by Coverity, a free static-analysis tool provided by Synopsis to open source projects. This tool analyzes the source code to check for common mistakes and errors, including static buffer overruns, null pointer dereferences, integer overflow, and other suspicious code. The coreboot project currently has over 380 flagged Coverity issues. The goal of this project is to make coreboot "Coverity clean". All outstanding issues will be classified, invalid reports will be marked as false-positives, and valid ones will be patched. This will address all issues with the current codebase, and ensure a common baseline for triaging new issues in the future.

Port and Integrate DRM ioctl in NetBSD kernel for Linux binaries running in NetBSD. Convert between 32bit and 64bit DRM ioctl calls. Create a test suit to run and test Linux applications in NetBSD.

This project intends to provide users or Malware analysts a platform which can assist in analysis of Linux Based IoT malwares. As IoT malwares are a booming threat, and due to heterogeneity of Malware architectures, resulting which the instruction set, system calls and stuffs related gets completely different and difficult for an analyst to continue. This platform will try assisting the analyst to conclude malicious intentions using the help of rules and signatures. Apart from that, it will attempt de-compilation , carry out regular manual analysis through Radare2 and attempt to provide ESIL emulations of selected piece of disassembly. Moving on from Static analysis, IoT malware analysts face enormous trouble setting up environments for dynamic analysis due to varied system images, custom tool-chains and many more reasons. This platform attempts to provide a detailed Dynamic analysis report upon user demand using Cuckoo and SystemTap scripts(As of now).

A new topology toolbox to gvSIG desktop. This tool will provide a group of integrity rules that will check the validation of the geometries relationship in the data. A new topology data model can be created for each project. This toolbox provide a new set of tools to navigate, find and fix validation errors different from each topology rule. Right now, there are just a few topology rules implemented with a limited actions. This project will analize, implement and optimize a new set of rules that will be incorporated to this framework. This tools can be created in Java or in Jython through the Scripting composer tool.

Swift for TensorFlow is a Swift library that helps develop and train ML models. Data Visualization can be helpful when exploring a dataset. It helps in identifying patterns, corrupt data, outliers, etc. It helps in the qualitative understanding of data. But as of now, there is no way one can plot graphs natively using Swift that works cross-platform. We do have CorePlot, but it works only on macOS and iOS. This project aims to make a Data Visualization library (similar to matplotlib) for Swift that works on Linux, macOS and Windows as well.

LTSP (Linux Terminal Service Project) allows diskless workstations to be netbooted from a single server image, with centralized authentication and home directories. But the project shows its age; the initial thin-client focused design is no longer suitable for the netbooted fat client/wayland era, and it contains a lot of stale source code. This GSoC project is about designing and implementing a modern replacement of LTSP.

This project aims to provide the capability of the FreeBSD ports infrastructure to safely and cleanly build ports and all their dependencies without superuser privileges, jails, or touching the installed system in any way, in the interest of improving the safety, reliability, and repeatability of ports building without the administrative and resource overhead of a separated build host or jail.

The main goal of this project is to implement a mechanism to be in sync with the latest human data submitted to dbSNP. Once imported, this information can be distributed via EVA implementations of the GA4GH APIs htsget and Beacon specifications, as well as the EVA website.

Acceptance criteria

Given a dbSNP FTP directory with the human variant information, the pipeline should parse JSONs for each chromosome and write the variants from the JSONs to the EVA archive

Needed tasks

• Construct an object model for dbSNP and parse the JSONs to objects in that model
• Convert the objects in the dbSNP model to the EVA variant object model
• Construct a variant object by including its component objects from above. Use the Variant writer of variation-commons to write the variants to the EVA archive

Passive acoustic observation of whales is an increasingly important tool for whale research. Accurately detecting whale sounds and correctly classifying them into corresponding whale pods are essential tasks, especially in the case when two or more species of whales vocalize in the same observed area. Most of the current tasks of whale sound detection and classification still need to be implemented manually.

We aim to develop two deep learning models for the detection and pod-classification of orca, or killer whale, calls in unknown long audio samples. These deep neural networks will help identify and verify killer whale calls so that researchers, grad students, and shipping vessels don't have to. The end-user interface can be made as a web-app which can easily be used by scientists in their research.

In the ten years since its creation, the Pharo programming environment has evolved greatly: it now has Github support and many cool tools; it’s faster, better and more convenient to use both for people who have been familiar with Smalltalk for decades and for complete newbies. However, there’s one thing that is behind in improvements -- code completion. And so having already had some experience with it, this is something I want to work on and improve.

As Eclipse 4diac allows programming of many different devices, such as Plcs, RaspberryPies, Lego Mindstorms, a runtime environment has to be compiled for each device. If you then want to extend the functionality with custom function blocks, a new runtime environment has to be compiled every time, a new function is created. However, compiling is complicated and takes time, therefore a Lua engine is integrated into the runtime environment, which then is able to execute Lua code, without having to compile it first.

Model zoo is a great compilation of deep learning and reinforcement learning algorithms. Currently state of the art baselines in terms of reinforcement learning and generative models are lacking in this package, which are present in tensorflow and pytorch. This project aims to add state of the art reinforcement learning algorithms like Proximal Policy Optimization and Trust Region Policy Optimization along with multi-modal translation and image captioning networks. These models are complex to implement and thus most users resort to standard tensorflow/pytorch implementations. Adding these to model zoo would attract a lot of researchers.

Hardware accelerators are necessary or at least desirable in many SDR systems. GNU Radio provides an open and free platform for designing real time SDR system. This proposal elaborates the architecture of Verilog design simulation integration, utilizing the existing tool, Verilator. With this Integration, Verilog simulation could be run at real-time, as a part of the SDR system.

Support for RTL (right-to-left) languages is still incomplete in Godot. While it supports Unicode fonts, adding proper support for RTL languages requires more functions to be implemented to be able to support languages like Arabic that require not only reversing the direction of typing but the cursive abjads (alphabets) of the Arabic script require different characters shapes depending on context. So, my project consists of building APIs and Implementing them in text controls to support correct layout of RTL text and to correctly handle BiDi text input.

Add to Cantor, a KDE program with similar functionality as Jupyter, feature to import/export Jupyter notebooks. It gives Cantor access to result of working Jupyter's community and solve the problem of sharing files Cantor users and Jupyter users. And also allow more easily migration from Jupyter to Cantor. Solving of mentioned problems could increase Cantor popularity

Usability and 3rd cutting-edge models are two main factors that are especially concerned by academic area. This project concentrate on enhancing both factors by extend the TensorFlow tutorial “A Concise Handbook of TensorFlow” (https://tf.wiki) to conform various features of TensorFlow 2.0, and develop a library containing clean, well-packaged and cutting-edge keras layers, starting from Graph Neural Networks and Memory Networks.

OSM2World is a converter that renders 3D models of the world, based on exported OpenStreetMap data. As the project is still under construction and some OSM tags styles are not yet supported, it is in the scope of this project to expand its codebase and include various aspects of traffic sign modules to its rendering capabilities.

This project aims at feature enhancements of Joomla 4. Easier module placement, adding information of the selected menu item in the menu overview list and the integration of the cookie consent plugin are the feature enhancements to be done for Joomla 4. These feature enhancements will make user experience more smoother and seamless.

HsYAML is a pure Haskell idiomatic implementation of the YAML 1.2 data serialization language with a strong emphasis on compliance with the YAML 1.2 specification.
We know that HsYAML library is already successfully in use still, there is lots of room for improvements. I am planning to work on the following features:
Implement YAML pipeline for dumping/emitting YAML
Extend data-model to allow for load/dump round-tripping while preserving ordering, anchors, and comments

The project is about implementing the computing extensive FindSim program on a cloud server and building communication between the web server and the computation server. With a high-performance server specifically set up for computing simulation tasks, the system can process more data with less time and the web server can provide better web service.

Implementation of core features needed for XR (virtual, augmented and mixed reality) headsets via the new OpenXR specification (currently in provisional state).

While virtual reality has reached mainstream adoption, it is still not possible to use this technology directly within Blender. There is great potential in the new XR workflows however. This project aims to introduce the core features necessary to build immersive experiences in the Blender viewport through OpenXR. Namely this concerns rendering and interaction with head-mounted displays (HMDs).

Molecular docking—the prediction of binding modes and binding affinity of a molecule to a target of known structure—is a great computational tool for structure-based drug design. However, docking scoring functions are mostly empirical or knowledge-based and the flexibility of the receptor is completely neglected in most docking studies. Recent advances in the field showed that scoring functions can be effectively learnt by convolutional neural networks (CNNs). Here we want to build on top of these findings and develop a CNN scoring function for flexible docking by extending the capabilities of gnina—a state-of-the-art deep learning framework for molecular docking—and by building an high-quality training dataset for flexible docking.

368/5000 About the project. The idea is to stabilize the project in python 3, perform unit tests (to test the migration to python3), add continuous integration (run the tests in each commit) and automated deployment (to assemble the packages and upload them to PyPi automatically). They are all things that would facilitate the development and installation of the project.

NpChat is a photo and file sharing application built on Android and is inspired by Snapchat. It runs over the Named Data Network (NDN) and focuses on decentralised information sharing architecture. It stands as one of the best examples of Android application developed on the new Internet architecture. During the GSoC period, I intend to develop this application from a working prototype to a finished application, with its first version released on the Google Play Store. Given the current state of the app, being a prototype, gives a big room for changes and improvements to be done in the coding period.

NextCloudPi (NCP) is a preinstalled and preconfigured Nextcloud, which can be used as cloud service to self host securely private data. NCP is open souce (you can find the code on Github) and it’s an official project of Nextcloud which is maintained by the community. The proposal describes the automatic installation of several useful and widely used open source applications on NCP, such as the online office suites, and the implementation of some new features and improvements on the existing Nextcloud server and web panel in order to make NCP more functional and useful both to novice and advanced users.

ThreadScope is a GUI tool for viewing and analyzing eventlogs to help developers understand and debug the behavior of concurrent Haskell programs. Currently, ThreadScope is inefficient when processing large eventlogs, makes it unusable for long-running programs. However, profiling such programs is of vital importance for analyzing real-world Haskell applications. This project will improve ThreadScope by loading and analyzing eventlogs in chunks to improve memory efficiency, making it usable for analyzing large eventlogs.

I am interested in the project “Appstore for the Cytoscape App” with Alex Pico, Barry Demchak and Scooter Morris as its mentor. My goals for the summer will be to improve overall user experience, security as well as accessibility of the Cytoscape App store by implementing following major goals:

1. Improving the user interface, particularly with respect to the search result display, redundancy in the search result, etc.
2. Writing test script for the website, both unit test as well as integration test.
3. Deploying the website on production server and Documentation.
4. Removing the remaining bugs in the code.
5. Web App implementation for viewing Cytoscape app store from within CyBrowser.

For tedana to expand, more extensive test cases are needed. A new contributor could have introduced an unknown bug into the codebase, but without extensive testing, there is no way to find out until a code review (and even then, it may slip through!) It would be wise to have vast and wide-ranging tests that catch the bug for the contributor!

For this project, I will write detailed unit test cases for the tedana codebase, hitting as many lines as I can while testing! I will also make changes to the functions themselves to type check the input parameters!

The OpenCV's DNN Module allows us to run inference on a pre-trained Deep Neural Network in order to accomplish high end vision tasks with just a few lines of code. However OpenCV's model zoo needs some new additions. Models that have acquired State-of-the-art (SOTA) in different computer vision tasks are somewhat lacking in the model family that is currently listed in the OpenCV repository. This gives rise to the necessity of adding new, powerful models to the list. The goal of this project is to curate more models for ease of use by the OpenCV DNN module and put them in a place where they can be easily accessed such as LFS on Git. The proposed project will add six (potentially nine) new models to the OpenCV Model Zoo. All of the selected models have, either state-of-the-art results in the task they perform or belong to a task category not currently present in the model zoo (e.g. Image Generation). The proposed workflow and the established timeline take into account worst-case scenarios, guaranteeing the project's completion and minimizing risks.

With booming amount of information being continuously added to the internet, organising the facts and serving this information to the users becomes a very difficult task. Currently DBpedia hosts billions of such data points and corresponding relations in the RDF format. RDF is a directed, labeled graph data format for representing information in the Web. SPARQL is a query language for RDF.

Extracting data requires a query to be made in SPARQL and the response to the query is a link that contains the information pertaining to the answer or the answer itself. Accessing such data is difficult for a lay user, who does not know how to write a query. This project will try to make this humongous linked data available to a larger user base in their natural languages(now restricted to English). The primary objective of the project being to be able to translate any natural language(English) question to valid SPARQL query.

Inclusion of USER_LDT option in NetBSD kernel allows Wine32 applications to be run on amd64 architecture. This is useful primarily owing to the majority of Windows applications being 32-bit. My work involves getting the latest version of Wine to compile and run on i386 and amd64, and building Wine with WoW64 support which will allow running Wine32 applications on amd64.

My proposal is a pirate-themed roguelike videogame that will showcase how powerful Pocket Code really is, while also delivering a fun and exciting experience for the player. The player will find himself helping cities, meeting colourful characters and fighting other pirates in a randomly generated adventure, and will face different challenges every time!

This project is to automate Reinforcement process by using Rebar Addon in FreeCAD. The idea is to create UI on top of the current implementation to combine different types of Rebars in a single Dialog Box as per the user requirements. For example, combine Stirrups and Rebars (different types of rebars) in case of Beam Reinforcement.

Improve the quality and reliability of the FEM Workbench of FreeCAD by introducing a extensive and consistent testing approach and developing a test suite covering the whole FEM module.

This project MapKnitter's Rails version from 3.2 to the latest stable version. Along with this, I will also be:

• Increasing test coverage
• Improving CI
• Refactoring code

The aim of this project is to build a compliance framework, to ensure that all new implementations/products/APIs adhere to the central specification defined by GA4GH. This framework would consist of pre-defined tests which can be reused for testing any new products for compliance during the product approval process, thereby reducing the cost of writing tests again and again. The framework would also include meaningful logging and a final report generation. The final reports would be published on a public website.

We will implement a MathOptInterface feature that allows JuMP to take an optimization problem in its primal form and return the dual form in terms of Lagrangian duality. The primary project goal is that this feature should work with linear optimization problems and conic optimization problems that can be written in pure JuMP (JuMP extensions will be a bonus).

The project does not depend on any other Julia packages; it should be a pure implementation that builds on top of the existing MathOptInterface.jl package.

The main project benefits are:

• Easily enabling all the users to exploit the dual formulation of an optimization problem (potentially gaining performance for the user application)
• Getting one step closer to allowing users to write the KKT conditions of a problem.

These two benefits are strong building blocks for the academic optimization community. They should bring long-term benefits to research in optimization.

Prombench the benchmarking tool for Prometheus will be extended to support even more tests, newer components, metrics which will help both developers and users in terms of identifying bugs and scalability tests. Another task the proposal aims to solve is the longstanding issue of Prometheus rule formatting.

Carbon Footprint Android App is currently in its beta testing phase, my main goal for this summer will be to introduce some awesome big features like Heatmap, Leaderboard and Push Notification alongside some small but yet effective features like Client-Side Password Validation, Autocomplete and Remove Friend Option. Additionally, improving UI/UX of the app and improving the current code structure is also an important task. Parallelly, the iOS version of the app will be maintained up-to-date with the Android version.

Often a low resolution image is needed to be up-scaled to a higher resolution. Even though there are already a lot of interpolation methods which accomplish that, none of them actually make the image look better and natural to the human eye.

Super resolution methods output an up-scaled image with improved details. The essentially unknown details in the high resolution output are filled in using different SR techniques.

For this project, I will focus on deep learning based SR using, mainly, EDSR and ProGANSR. I will train and model these architectures with PyTorch and convert them to ONNX representations which the DNN module (OpenVINO) of libXcam can infer from.

DIRAC is an open source interware platform whose roles are submission of jobs, the management of the data produced, to the orchestration of the distributed resources. It is a generic software, used and extended by several Virtual Organizations (VO).

It monitors resources like computing, storage, catalogue resources, networks, information providers, file transfer services, message queues or databases services. Members of a VO can use a mask composed of services exposed by local resources. Experienced Grid administrators apply procedures for managing such services, based on their status, as it is reported by an ever-growing set of monitoring tools. When a procedure is agreed and well-exercised, a formal policy could be derived.

For this reason, using the DIRAC framework is developed as a policy system that can enforce management and operational policies, in a VO-specific fashion.

This project proposal offers :

• A reliable working implementation of a multi-VO Dirac Resource Status System (RSS).
• A base database access module for the RSS which would unify the SQLAlchemy frontend and also reduce code duplication.
• Remove sqlite3 from some RSS modules and port them to MySQL backend

Currently, beam elements (much like most of the deformable structural components) only deal with the (visco-)elastic characteristic properties, whereas the modeling of the inertia properties of the component are delegated to a set of equivalent "rigid bodies", i.e. lumped inertia components. This project is aimed at introducing consistent inertia modeling for beam elements, i.e. inertia forces and moments are generated directly within the beam element structural component, starting from beam section inertia properties per unit span.

Open event project provides a platform for managing all the activities in an event. It has different mobile applications for both attendees and organizers. My proposal aims at enhancing the attendee app by providing more event information, integrating more payment methods and improving the registration process. In the current state of the app, all features are implemented according to the previous version of eventyay server. My goal is to integrate new features which are implemented (or will implement during GSoC) in the frontend (https://next.eventyay.com) and the server (https://api.eventyay.com/).

The R package highfrequency is the go-to package for intraday financial analysis in R. In the project, I will enhance its functionalities, rework some of the foundations and expand its documentation.

Use snapshots (shallow copies of the document) instead of actions for the purposes of undo and redo in Krita. This simplifies the system and makes it easier to maintain.

digiKam is a well-known desktop application for photos management. In digiKam, tags on photos are strongly supported for the sake of providing users with a natural workflow of searching and arranging photos in their collections. Since many of our photos contain faces, face tag has apparently emerged as an essential property for any photos management software. Being aware of that, digiKam team has put a lot of efforts to develop face engine, which scan scan photos and suggest face tags automatically basing on pre-tagged photos by users. However, that functionality is currently deactivated in digiKam, as it is slow while not adequately accurate. Thus, this project aims to improve the performance and accuracy of facial recognition in digiKam, in order to bring this wonderful functionality back to users in a very soon release.

This is the proposal with respect to the task I'll be pursuing in the GSOC 2019. In this document I've briefly explained about the task I'll be doing like OIDC, Edit contact improvement, Adding several accounts, etc.

An application from Jingrui for Céu-Arduino, I'll do my best for that.

This proposal suggests a full-featured modern user mentions feature with additional improvements for Apache Allura. User will be able to mention other users in a comment with the help of an autocomplete list. Thereafter, notification emails will be sent to related users. Furthermore, there will be an option for users to turn on/off notifications as they wish.

The project consists of developing an interface, in Lua, for the set of Cloud IoT Core APIs, through two REST resources:

• cloudiot methods, to facilitate device manager tasks
• cloudiotdevice methods, to facilitate device communication over the HTTP bridge

The Proof of Concept

• Another task is to provide a Proof of Concept by using a real world device such as NodeMCU/Raspberry Pi interfaced with temperature sensor to send the temperature data over to the Google Cloud IoT Core.
• Doing the reverse, sending the data to the device using the Google Cloud IoT Core. We expect this data to be a Code Snippet, which would run dynamically on the device every time it is interrupted by the new code received.

Development of a software interface with REST support in Lua

• With a minimal GUI this application will make the life of a person using Lua REST APIs easier by providing a simple interface to send and receive data from an endpoint.
• Testing would be done using the Proof of Concept developed above.

Ganga is used to execute a user defined computational task on a distributed back-end. Through this project we let the users define the environment in which their task need to be executed. So the worker node will pull the user defined container and execute the task on it.

Terasology is designed to be a modular voxel engine but as said: “with great power comes great responsibility”. Keeping track of all the modules can be tough. The idea of the proposal is to provide an automation system that aggregates all the modules and display their information on a generated website. Provide a way for the user to download, list dependencies. With a stretch-goal of improving the UX of the website along with speed and accessibility.

Bassa is currently limited to being an internet download manager, providing efficient use of internet bandwidth. The vision of the project is to scale it to a full-fledged file management platform involving file storage (on the server), uploads, downloads and collaboration among users via sharing resources (files, in this case), much like Google drive or One Drive.

The project is aimed to design and implement the JSON API to programmatically query the BookBrainz database. Since the existing backend of BookBrainz website is written using node.js and its framework express.js, therefore we will also use the node.js and express.js to implement this project. This API will use the current BookBrainz ORM bookbrainz-data-js to access the database.

I propose to extract and analyse the Body Gesture and Pose of the people depicted in the paintings, artwork and sculptures of the medieval period.I also propose to interpreted the scenes depicted in the paintings like time of the day,indoor or outdoor,well decorated room or cottage. Along with that, I will also analyse the Christian Iconography and the interaction.I will extract the key-points from the images for human pose estimation, by detecting and localizing the major parts/joints of the body in the image containing individuals. I will also extract emotion depicted in the images using face keypoint detection.I will also train a classifier to predict emotion on the basis of pose.I will also visualise the clusters of images based on emotion and pose.All techniques proposed here have been applied previously on related problems in image processing.

Poliastro aims to be an open source library for aiding Astrodynamics and Orbital Mechanics. However, a lack of interactive visualization tools is apparent. My proposal aims to build a module to extract orbital data from poliastro and visualize them using the open source 3d mapping application, Cesium.

With the coming revival of bit utilities paper for the C++ Standard and the potential of a new suite of bit utilities coming from a header <bit> [5], the goal of this Google Summer of Code 2019 project will be to identify existing algorithms where libstdc++ will benefit from additional overloads based on using the bit iterators. This proposal also explores the fundamental appeal of broadening this class of optimizations to types that are not only represented by bit iterators or std::vector<bool>, but any type whose bits are trivially relocatable under the upcoming work of Arthur O’Dwyer.

OWASP Honeypot : The idea is to: -Test all the modules in the code (currently 4)and if there are bugs found to fix them. -After testing the entire codebase, would remove the duplicated code. -Then I would like to work on packet tracing,currently only the information like IP Address and Country is being extracted from the packets and it's not that useful to classify it as high risk or not.So I would discuss with my mentor as to what all needs to be extracted from the packets and would store in the database.

• After that I would like to start with the WEB part of the project,to write new routes and add new visualizations.(this part I am most comfortable with because I already have some industry experience with web) -Then would add new visualizations for the extracted details and also some logic to classify the record in the database as high risk ip because now we would have more information from the packet and not limited to IP Address and country -Also in between testing modules and removing duplicated codes I would work on PR reviews and issues (if there are any raised or found) -Finally at the end would document all the work I did in the wiki section of the project.

The aim of this project is to carry out a rigorous and deep case study of Index Checker by annotating Apache Commons Lang with the same. The plan of action is to annotate, find and report bugs(if any) and provide enhancement suggestions, including improvement in the error messages. If there is time left, I'd repeat the above procedure with another tool.

It is better to discover performance problems sooner than later, but this is even more important if we are talking about a database. The newly introduced performance flaws are hard to notice, and the process of discovering them is cumbersome if done manually. Since Prometheus TSDB does not have such a feature yet, this project should be the solution. Meaning, the plan is to develop detailed performance tests and automate the process of testing using Prow, the Kubernetes based CI/CD system with GitHub integration. Moreover, for easy analysis, the results of the benchmarked pull request will be compared against the master branch test results. Fortunately, the foundation for implementing the benchmarks partially exists, and so do some benchmarking tests, which means an excellent start for the project.

The sequencing technology produce the DNA sequence information of tumor cells. And cBioPortal is one of the leading web-tools which collected tumor sequencing result and provides visualization and exploring function. The tumor is not homogeneity, the mutations were accumulated when the cell divide. The different parts of a tumor can be the clone of different cells with obvious genetic distance respectively. This project aiming to construct a front end module to estimate the clonal evolutionary relationship using multi-region sequencing data. TBD

This project focuses on creating an awe-inspiring game using pocket code with the goal of sending the message on “ what kind of unimaginable feats can be achieved using pocket code”. In order to realize this, the game being built will be inspired by the recently popular 2D title - “The binding of Isaac(BoI)”. Whilst certain characters and parts of the storyline will be the same as the BoI, I am also looking forward to implementing original cutscenes, characters, monsters, weapons as well as different endings and a seperate set of features varying from the original game.
Successful completion of this project will result in inspiring other audiences to use pocket code to create more apps, further enforcing the vision, “Computational Thinking for All with Free Visual Coding Apps”.

This project proposes to build an infrastructure that helps the R community explore R user groups, R-Ladies groups and past R-GSoC projects using a data-driven approach to render dashboards that summarize trends and insights to enhance better decision making for R centered organizations, the R Foundation, and the general community.

Training of High end Deep Learning Models takes a Long time to Train, Hours, Days and Even Weeks. So, as a Developer/researchers it slows down the creativity and implementation cycle. The Whole Idea of Transfer Learning provides a nice solution where a model trained on a similar dataset can be trained partially or fully, on the custom dataset, yielding similar result. TFHub is a platform by Tensorflow where pretrained models are shared, so that developers and researchers can use transfer learning on these models. In this Project, The Following Pretrained Models and Their Demos will be added to TFHub:

• DeepPose (Trained on Leeds Sports Dataset)
• DeepPose (Trained on FLIC Dataset)
• Enhanced Super Resolution GAN (Trained on DIV2K Dataset)
• Sequence to Sequence Models for Generating Video Captions
• YOLOv2 (Converted from ONNX) And if Time Permits, The TF.js Compatible Version of these Pretrained TF Graphs will also be added.

The goal of this project is to implement encoding and decoding of GB2312 for perl6.

Neovim’s job control feature introduced great multitasking support that added new capabilities and enhanced a lot of important tasks (e.g.: online linting, like in ALE for instance), making them asynchronous and non-blocking. This improved the editing experience and reduced latency.

Here I propose to work on adding multiprocessing support to VimL and Lua scripts by allowing functions to be invoked asynchronously in separate processes and enabling the retrieval of their results either through callbacks and/or by waiting for them on demand in the parent process.

This multiprocessing feature will have a noticeable positive impact on the performance of tasks that can do their computations in a parallel manner or that may want to spawn workers to process some data or to do some offside work while doing their main job.

Bayesian Additive Regression Trees (BART) is a Bayesian nonparametric approach to estimating functions using regression trees. A BART model consist on a sum of regression trees with (homoskedastic) normal additive noise. Regression trees are defined by recursively partitioning the input space, and defining a local model in each resulting region of input space in order to approximate some unknown function. BARTs are useful and flexible model to capture interactions and non-linearities and have been proved useful tools for variable selection.

This project aims to improve the existing Nextcloud integration within Rocket.Chat. Seamless authentication and improving the UI and UX of the file picker are the main focus.

OpenMRS needs location based restrictions like privilege level access restrictions. So the Location based access control(LBAC) should provide a restriction mechanism to restrict user access only to the logged in location of the authenticated user. That way, if someone is logged in a certain location, they should see only those encounters, observations, and patients registered in that location. But the System Developer account should be able to see patients in all locations.

CrowdAlert practically addresses a really good problem we are trying build a solution for. It's solution boils down to having a robust and real-time end user experience.

This proposal is about core optimisations and addition of new and exciting features to the user experience of the React application. That implies, using Server-side Rendering for faster page loading times (significantly low Time To First Byte), using web-sockets for real-time updates for incidents, comments and HTTP Long Polling for upvotes etc., migrating to more robust, scalable and available database solution, finally, decoupling it from Django views. Then we need to write consistent tests to validate different models and fields. Finally, an NFSW image classifier. Eventually, we will end up with cleaner code, sound application architecture of both frontend and backend, adding more tests and developing/revamping new features are the most obvious ones. This will not only make developing new features much more easier, cleaner and maintainable but will also dramatically improve user experience and take it to next level.

Firefox Profiler is a tool which visualizes performance data recorded from various performance analysis tools, which helps us to have an insight into our app’s responsiveness, Javascript and layout performance. By using it efficiently we can optimize our app in terms of performance. Currently, it supports Gecko, chrome, and perf(Linux) profile formats. This project will provide support for visualizing profiles from Instruments which is a powerful and flexible performance-analysis and testing tool that’s part of the Xcode toolset.

GStreamer plugins are written in C and the developers are pursuing in an attempt to convert them to Rust which is more robust and easy to maintain. I will be a part of this conversion and help to fix certain issues related to this. This may require lot of testing and careful implementation of the C written program in Rust.

Condition list is a list of diagnoses, symptoms, or findings that are being tracked over time (i.e. across encounters)

JuliaText is the JuliaLang organization that provides with packages to work with text. It currently lacks support for basic problems like Named Entity Recognition, Part-of-Speech Tagging, Dependency Parsing etc. which help serves as the basis for various language processing problems and analysing text.

I propose to implement practical models for Named Entity Recognition and Part-of-Speech Tagging in Julia and extensively test and validate them. Robust and well-tested APIs for these two tasks will be written.

Software Heritage is an ambitious research project whose goal is to collect, preserve in the very long term, and share the whole publicly accessible Free/Open Source Software (FOSS) in source code form.

The Software Heritage data model is a big Merkle DAG made of nodes like revisions, releases, directories, etc. It is a very big graph, with ~10 B nodes and ~100 B edges, which makes it hard to fit in memory using naive approaches. Graph compression techniques have been successfully used to compress the Web graph (which is slightly larger than the Software Heritage one) and make it fit in memory. The goal of this GSoC is review existing graph compression techniques and apply the most appropriate one to the Software Heritage case, enabling in-memory processing of its Merkle DAG.

A library for creating data structure with same functionality as DataFrame in R or pandas

This project aims at introducing new features to detection suite like adjustable bounding boxes, ability to add new labels , draw bounding boxes around the object of interest to get its labels and develop a ros-node of the suite. And also on improving the user interactions by adding few new GUI features like playback options , class-labels work-space and easy to start interface.

Current version of Remoting over Apache Kafka plugin requires users to manually configure the entire system which includes Zookeeper, Kafka and remoting agents. It also doesn't support dynamic agent provisioning so scalability is harder to achieve. This project aims to solve two problems:

1. Out-of-the-box solution to provision Apache Kafka cluster. More specifically, users can connect with a Kafka server seamlessly by either local binary files, Kubernetes container or from a Software-as-a-Service provider.
2. Dynamic agent provisioning in a Kubernetes cluster. This can be done by implementing Cloud API or integrate Kafka agent launcher in Kubernetes plugin.

This project focuses on improving Open Robotic's simulators through creating a Gazebo Visual Plugin and Sensor Data Visualization. This will involve implementing a GUI that will overlay Gazebo that will display important information including current task, number of points, penalties, and useful debugging information. In addition, this will involve writing loadable plugins for sensor data visualization using Ignition Rendering.

The 2.1 SPDX specification source files exist in markdown and now generates an HTML version The goal in this GSoC will be to find an approach to generate both HTML and PDF versions of the SPDX Specification from Markdown (MD) such that changes to the source files(MD) in this repository are automatically reflected in both versions.

Sampling algorithms and volume computation of convex polytopes are very useful in many scientific fields and applications. The package volesti is a c++ software with an R interface being the first package providing such a variety of options in geometric statistics. It currently scales to a few hundreds dimensions and hence it could be an essential tool for a quite large number of scientific applications. However, the possibility to scale from a few hundred to a few thousand dimensions was considered as a very far-reaching goal for many years. The goal of this project is to provide the first ever implementations for sampling from convex polytopes and volume computation in a few thousand dimensions. We exploit some very recent theoretical results that guarantee fast convergence and numerical stability in order to propose an efficient implementation of the current state-of-the-art geometrical random walk algorithms. The proposed implementations will be a decisive contribution to other scientific fields as computational geometry, finance and optimization. We give a week time schedule. We hope this project will help educational programs, research or even business communities.

In the current scenario, A user logs in the desired intermine and saves the results and the required data. The problem arises when the same user wants to access a different intermine, He/She will have to register again on this new mine and log in again. So , Currently Intermine community does not have a single common sign-in mechanism and thus it is authenticating users with the help of tokens (temporary and permanent one) or using google and Elixir services to log in. This project will modify the existing token mechanism by making the intermine as an OAuth2 provider with a single common Authorization server for all 30 mines so that user could access all the mines with the single set of credentials i.e just one time registration.

The Project has 3 sub-parts which are described as:

1. Initial Firmware Retrieval: People who want to update their device, often do not know what firmware file to download. So far the best option is the Wiki, but it is often loaded with too much information. The file download organizes all images files by architecture, but that is what most user usually do not know beforehand.
2. Firmware Upgrades: Create a router web interface package for LuCI to check and apply new images.
3. Creating meta-data for each target: To get the data for both projects, the OpenWrt build system needs to modified to create json files with the necessary metadata.

A common sight on today’s streets is the number of abandoned animals languishing on the streets suffering with injuries and disease and live without a any shelter. The silent suffering of these souls caught the attention of dynamic, animal lover, so Animal Rescue App initiative to develop a mobile app to track animals that are in need of help. Animal Rescue App Connect animal lovers, vets, and other NGOs in real time. They Can Track the Animals That Actually Need the Help. The Mobile Application will Implement From the React native using the Components of the Go social and firebase and the admin Website from the React js and firebase.

ROOT has several features which interact with libraries and require implicit header inclusion. These headers are often immutable, and reparsing is redundant. C++ Modules are designed to minimize the reparsing of the same header content by providing an efficient on-disk representation of C++ code. Although C++ modules support in ROOT has been implemented in the last few years, there is still room for performance improvement, and GlobalModuleIndex implementation is one such possible solution. It is a mechanism to create the table of symbols and PCM names so that ROOT will be able to load a corresponding library when a symbol lookup failed. It is expected to improve ROOT’s performance by speeding up its startup time.

For the past several years 360° cameras have become far more accessible, and several video-sharing services enabled support for 360° videos (for example, YouTube and Facebook). Nevertheless, FFmpeg currently doesn’t support any of 360° video formats.

The goal of the project is to write a filter which will be supporting all 360° video formats found on the Internet, as output and input. A filter should also support all basic 360° transformations: rotations (roll/yaw/pitch), Field of View extraction, etc.

Bassa project is about making installation of Bassa easier for its users and containerizing in a better way to use available resources in efficient way.

Bringing Minio into Bassa for proper file storage will be first task, later on currently written Bassa installation scripts will be updated by proper and efficient DockerFile for each Bassa components (minio storage, MySQL DB, (Bassa socket server + aria2c) ) which will be treated as Docker containers and then these Docker containers will run in pods as described briefly in proposal and these pods will be run as clusters in k8s environment

Bassa socket server and aria2c together will work as single instance pod and will be auto scaled to attain good uptime and other components Minio and MySQL will be working on different pods, these pods will interact with each other and transfer files to minio buckets created by user.

This project will improve and extend Dynamic Learning, a project created by Jithin KS as part of his 2018 Google Summer of Code project. Dynamic Learning is a platform in which teachers and programmers can collaborate with one another to create visualizations of common STEM topics. My project will improve this application by focusing on three major areas of extension: interface changes and responsiveness, integration with other software, and classroom usability improvements. I will also add a few miscellaneous improvements towards the end of the project.

Writing the driver of AD5940 in the IIO subsystem and add support for manipulating ADC channels, DAC channels, internal temperature sensor and GPIO lines.

Planned features: [OPTIONAL] Scheduler Jobs UI. Continued refactoring and performance improvements. Improve UI and workflows. Implement TOTP based two-factor authentication. Improve and stabilize GIS functionality. Improve KYC features and client onboarding workflow. Implement in-app push notifications via SMS Campaign API (Direct, Scheduled, Triggered). Design and implement UI for Maker-Checker (tasks) list. Improve UI for viewing reports and support exporting to CSV. Improve the existing UI and workflow for survey inputs. Unit and integration testing.

Finding the best example of full-stack Haskell web development project is hard as a beginner to intermediate Haskell developer. This is based on my experience when learning Haskell for web development. Moreover, many misinformed statement regarding how to do web development using Haskell especially about the library, tooling, and architecture to use leads to make a Haskell newcomer afraid to express their idea in web project using the language.

Hackage Matrix Builder is one of the example project which planned to be a full-stack functional programming project that can help beginner to see how web based project looks like using Haskell. However, it is not entirely use Haskell and it sometimes make it hard for newcomer to learn two language at the same time for their example project. In addition, Hackage Matrix Builder is one of the project that aims to provide the best build compatibility test service to the Haskell community for all the packages published on Hackage.

In this project, I am aiming to make a full-stack Haskell web development project example as well as adding UI feature in Hackage Matrix Builder to maximize its purpose as QA or CI service for everyone.

Currently RetroShare Android app is in the early alpha stage with basic functionality written in QML. Although the core functionality is implemented, its unappealing design makes this app unusable and discourages potential users to join RetroShare network.

New app is intended to make communication over RetroShare possible on Android. Users will gain additional access to RetroShare network through their phones, and by focusing only on the core functionality it will make joining network simple and entertaining.

The second part of the work is to extend the backend of the chat with the function of asynchronous messaging and storing the history of messages.

Migration of official TensorFlow models to use/support TF v2.0 features/functions.

Bricks are the fundamental tools, which are needed for the development of projects within the Pocket Code app. Therefore, I would like to contribute by implementing the missing bricks for Catrobat Language Version 0.992, which would implement essential features that are missing in the current app store version. These missing bricks are, for example, the GoToBrick, the WhenBackgroundChangesBrick or the CloneBrick, which are extremely useful, if not essential, and already implemented in the Android version of the app. These improvements would raise the functionality and quality of the iOS app to a new level, which ensure an even better version of the app than ever before.

This task focuses on improving DevOps for Carbon Footprint Web Extension along with adding new features so that new users can benefit from the extension :

1. Integrating Web Extension tests (E2E testing) : Currently only core functions are tested using unit testing, students are supposed to use puppeteer for testing the whole extension. In this way, the whole extension will be tested before deploying/commiting helping us to keep the extension more stable. Student will have to write tests for all the websites currently supported by extension along with tests for the websites which will be added during GSoC project.

2. Extension support for cruise: Currently, the extension only supports the calculation of carbon emission from airplane, train and cars. Students are supposed to integrate cruise calculation to the extension too. This would help more people who use extension to calculate the carbon emission. Calculation of carbon emission of cruise is significantly different when compared to aircrafts, cars and trains. In your proposal clearly explain your approach and give links to relevant documents.

One important characteristic for microbiome data is the number of microbiome is far larger than small sample size (n>>p), resulting in a high-dimensional problem. In this proposal, we will develop a deep learning prediction method ”Tree-regularized convolutional Neural Network,” (tCNN) for microbiome-based prediction. The advantage of tCNN is that it uses the convolutional kernel to capture the signals of microbiome species with a close evolutionary relationship in a local receptive field. Moreover, tCNN uses the different convolutional layer to capture different taxonomic rank (e.g. species, genus, family, etc). Together, the convolutional layers with its built-in convolutional kernels capture microbiome signals at different taxonomic levels while encouraging local smoothing induced by the phylogenetic tree. ‘tCNN’ is implemented in user-friendly R package based on TensorFlow.

Super Resolution is a subset of algorithms that aim to up-sample a lower quality image to a higher quality one. It’s goal is to create an up-sampled copy that is as detailed and visually pleasing as possible. It is used in a wide range of fields, such as medical image processing or surveillance camera stream processing. Using deep learning models for super resolution is a widely researched area, as they generally achieve better accuracy than classical computer vision based algorithms. There are many popular type of models used, ranging from supervised learning to unsupervised learning methods. I propose to implement two deep learning based models to be a part of the OpenCV library. One is EDSR, which is a residual network based model, and is known for it’s high accuracy. The other one is LapSRN, which is a fast, but still accurate model, that can be deployed to real-time applications. So integrating these two OpenCV would obtain a model that achieves state-of-the-art accuracy, and another one that can be deployed on devices that have lower computational power, while still maintaining high accuracy.

An ‘English-Lingala’ language pair using Apertium rule-based machine translation system.

Parameter estimation and uncertainty propagation are salient aspects of applied dynamical systems of practical interest. Both parameter estimation and uncertainty propagation are handled elegantly in the Bayesian framework, and made easy by PyMC3. Current numerical integrators in the scipy ecosystem do not return gradients with respect to the parameters of the system’s solution, preventing PyMC3 from using these integrators in the No U-Turn Sampler. This project seeks to implement methods for computing gradients for use in PyMC3’s MCMC capabilities, thereby allowing applied researchers to analyze their systems in the Bayesian framework through PyMC3.

An engine in C++ to run the Mission Supernova 2 game on ScummVM.

The aim of this project is to extend the current Synthesis State Watcher to additional low level waveform in different stage of producing note during Add synth, Sub synth etc. In additional, an oscilloscope-like view will also be implement in the UI, this will provide user the opportunity to see live progression of the intermediate waveform after filter, before mixing with another note etc. Allowing the user to see this them to understand how different parameter affect waveform of the sound and result in better music!

Laying down a strong foundation & base architecture for Intrusion detection & prevention system (IDS/IPS), intelligent log monitoring, antivirus that can be scaled in future and also can be further expanded easily by applying machine learning. Enhance the current firewall by bringing in some advanced rules to detect malformed & suspicious packets & dump them into a PCAP file for future forensic analysis. Implement OSINT tools to collect information about attackers and generate a CSV report. Introduce Auto Server patcher to patch server configuration for maximum security features and implement a server-side web deface detection. Also, protect IoT devices by checking if they are under the Shodan radar. Perform all the elemental connections & introduce different modes for the user. Improve the GUI by adding all the configurations options and critical data such as last login to it. Perform bug fixes and improve the dashboard. Write detailed documentation and README, and finally package and ship SecureTea version 1.1 on PyPi.

My goal is to rewrite the current lightmapper used in Godot in order to add some quality improvements and eventually allow it to use the GPU to speed up baking times.

I will explore what ray tracing libraries are openly available and choose the most fitting one. Finally, I will integrate a denoising algorithm to achieve better looking results with a reduced amount of samples.

This project focuses on making the integration of Application providers with Owncloud, vendor and platform independent. This will give the flexibility to the users to choose application according to their needs.

This project aims to create new API to enable multiple network interface for Rook storage providers. Currently, Rook providers only choice is to use hostNetwork or not. The new API will be used to define networks resource for Rook clusters. Rook operators will be able to consume those definitions and manage them. Therefore, it enables more fine-grained control over storage providers network access.

Merge conflicts are part of every version control system structure. There can be situations in which some changes are necessary for a piece of software to function properly but, an unexpected merge conflict may lag the development workflow. The user may want to store a partially resolved merge-state if they have to fix an urgent bug. In the current scenario, they are only allowed to either fully resolve conflicts or abort the operation that led to conflicts by discarding the partially resolved state with conflicts. This project is about adding functionality to store an unresolved merge-state to help the user on such occasions. This lets the user do the required tasks at the moment in the same repository and get back later to the same merge-state and resume resolving conflicts. This project also adds functionality to let someone else do the conflict resolution for the user if they want by committing the conflicts and sharing it with other users.

Librecores provides a platform to share projects and ideas, in the area of free and open source digital hardware design. Librecores CI is an approach/service to provide continuous integration to hardware projects hosted on Librecores to improve user experience and reliability. This project aims to provide automation service for some hardware projects that have a constantly evolving code. Jenkins, the automation server will be used to achieve the goals of the project.

Some functionality in SunPy or in affiliated packages is going to need access to data files on remote (HTTP) servers. Examples of this include data provided by instrument teams relating to the calibrations or performance of the instruments, these kind of data are highly likely to change with time.

This project needs to be designed and implemented under the assumptions that SunPy has no control over the data on these servers, and that files on the servers may be replaced with different files with the same name.

SymPy is a Python library for symbolic mathematics. Sympy has a powerful solve function that can solve a lot of equations, but due to its complex API and inability to give efficient output, solveset was implemented and is under development since 2014. A lot of work is needed to complete solveset. For transolve, Lambert solver needs to be completed. Handling modular equations will also be added. Proper use of Decomposition and Rewriting principle also needs to be implemented to solve nested trigonometric equations. Enhancing the set infrastructure to give simplified output for trigonometric equations is also needed along with integrating helper solvers with solveset.

The primary objective of the project is to generate both HTML and PDF versions of the SPDX Specification from markdown. The HTML and PDF version will be generated for each draft and release version of the specification. A tool which would help in easy circulation of the the SPDX specifications by creating a HTML and PDF version of the same. Conversion is important for the resource sharing capability of the specifications.

After establishing a stable IKEv2/IPsec connection there are chances of connection failure due to poor network connectivity or user going to standby mode etc. Suppose we have a VPN gateway where it has a large number of connections with remote clients failure recovery after a network loss leads to large computational needs as it needs to establish all the client connections again by performing all SA protocols from the phase 1 of IKEv2. In order to avoid this overhead to the systems an effective session resumption utility is required. This proposal focuses on the way to implement and add this functionality to the existing IKEv2 of the Libreswan Project.

Apache Camel focuses on making integration easier by providing the implementation of Enterprise Integration Patterns (EIPs), great API connectivity and easy to use Domain Specific Language to combine and transfer EIPs. GraphQL component in Apache Camel will act as a Query Language as well as middleware between the clients and server.

Currently, ChainKeeper is working as a web application which can use for the retrieve blockchain data for any kind of purposes. And it has an inbuilt API to do this. But as I understand and defined in the project description ChainKeeper is not capable to use as an analysis tool due to its constraints. Retrieving block by clock or tx by tx is not a good way for the analysis scenarios. There should be a more efficient and optimized way to do this. This proposal will address about the above mentioned problem with an optimized blockchain analysis library.

This project aims at integrating a JavaScript engine into VLC to enable extensions development and scripting support inside VLC in JS. This project should replace the already existing Lua engine.

Getaviz, last year added A-Frame as visualization framework. However, the performance of these visualization is still unsatisfactory. The problem is most likely, that the generated visualizations need too many draw calls. The goal of this topic is to improve the performance of these visualizations. BufferedGeometry and instancing are two important methods that can help reduce draw calls and improve performance by get rid of unnecessary calls to the GPU and save on rendering.

The Commons RNG emphasizes upon the utilization of Java-only implementations of various standard pseudo random number generators i.e. the generators produce deterministic sequences of bytes, currently in chunks of 32 and 64 bits, with focus being placed on fast generators with strong uniformity and predictability, with this project involving the creation and debugging of various Pseudo random number generators, including :

• Lagged Fibonacci Generators
• Linear Congruential Generators
• Permuted Congruential Generators
• Middle Square Weyl Sequence Generators and more.
  The addition of these generators shall help overcome many of the shortcomings of Java's standard library implementation (more information provided here- https://commons.apache.org/proper/commons-rng/userguide/why_not_java_random.html ) and provide for the ease of creation of various types of Java programs involving data simulation, gaming and gambling.

Further details can be found in the JIRA Issues forum link below : https://issues.apache.org/jira/projects/RNG/issues/RNG-32?filter=allopenissues

Many scientists around the world perform structural network analyses on the MRI data during neuroscience experiments or studies. Scona was designed to make this experience better and to help researches run brain analyses quickly and reliably in order to capture many aspects of brain structure and function. Right now it is a well-documented, tested python package that is easy to use and re-use.

My project is mainly focused on the visualisation part that will be included in the scona package.

• Within the scona package visualizing results would be easier for scientists, as they will not need to link together lots of different packages, just use out-of-the-box available functions, that will meet their needs;
• The implemented visualization functionality will allow users to produce “publication-ready” plots, based on the results of the performed analysis;
• Neuroscientists will be able to export created figures to include in their publications asserting that the quality of images in the pdf file will remain the same as in the web browser;
• Additional goal is to build up example analyses (and its visualisation) using openly available datasets;

The project aims to build a machine translation model that can convert Sumerian (Language used around 2000 BC) to English Language using Neural Networks. The model should be bidirectional i.e It should convert Sumerian to English as well as English to Sumerian. Neural Machine Translation (NMT) is a new and highly active approach, which has shown promising results for machine translation task. I would like to use Basic Encoder-Decoder Architecture for Machine Translation Problem both encoder and Decoder will be implemented using RNNs (specifically LSTM and GRU units) where Input encoded sentence along with previously learned word embedding as vector will be given to encoder which generates a fixed length context vector, Decoder takes that vector and will generate target language translation. But it performs poorly with longer sequences sentences, to overcome this problem we will improve it with attention-based encoder-decoder model. For complete details please have a look at PDF attached or Google Doc draft.

Model Visualization Plugin for App4MC - Eclipse IDE

The world in which we live in is evolving faster than anyone can expect. New Technologies and Systems assisting us in our general life, from the invention of the electric power, over smartphones, up to self-driving cars. This was a big step in human evolution and gives us a small insight on what is to come in the future. In this future the technical requirements are going to be higher than ever. This will increase the importance of multi core real time systems more and more.

The goal of this project will be to increase the important aspects of the App4MC platform with a user friendly and customizable representation of this data in the form of a plugin for the Eclipse IDE.

OCR is a very wide application which translates characters in the image to an editable format. OCR on television news shows would recognize any text appear on a screen and translate this text to editable formate at one-second intervals. During OCR development some challenges appear, one of these challenges is to detect duplication if text repeats in successive frames, the application will handle this case. Another challenge is to see if it is time to make space between words or not (i.e. space detection) as the output may be all words concatenated together and space some times not detectable in frames. My work will be based on CNN and BLSTM VS open source libraries the best accuracy will be deployed. The project will be deployed on HPC machines using Singularity containers. Another contribution will be also done an enhancement on ASR (Automatic speech recognition) which is done last year by Ahmed Ismail. This project will be trained on a new dataset and new modification to the architecture may be done (if required ) to increase it is accuracy.

The current representation of reference genomes is as a sequence of nucleotides akin to a long string. Intuitively, this doesn’t represent a genome but rather a consensus. A workaround used today is holding variation data in VCF files that don’t update the reference meaning the reference will always represent the genome as it was not as it is or as it’s evolving. It’s clear that the current method of representing genomes is not ideal. There is a need for a representing the reference in a data structure that contains its inherent variation. Different methods have been tried and the variant graph is a promising one. The way the graph works is by representing the variation within the genome as alternative paths one can traverse the graph through and conserved regions as nodes without alternative paths to the get to the next node; we then index the nodes for querying and alignment. Moreover, variation graphs hold an advantage with rapidly evolving genomes and short read data that could get thrown out when it doesn’t have a place to align to in the reference; with the variant graph short reads should reads could align to alternative nodes.

Genpipes is a set of software pipelines designed for genomic analysis. There are currently seven different pipelines and three more are in the development phase. These pipelines consist of several steps (10-40). Therefore keeping track of which step was executed, what functionality did it provide, at what time it was executed, whether it failed or succeeded can be a cumbersome task. The project consists of an integrated system that automatically builds a flowchart of the steps executed by the user. This would be a user-friendly add-on to the software as having a flowchart of the steps executed would help in the analysis and understanding of the process performed.

A changepoint is typically defined as a point in time where the distribution of a data-stream changes in a distinct manner, for example, typically one may look for changepoints in mean, and/or variance. Usually, this is performed in an unsupervised setting where we have no labelled examples of true changepoints. However, in practice, we usually have examples of periods of time where we know no changes should be present, or conversely where changes are expected to exist. When and where such information is available, we can potentially use this to aid our judgement of how to set complexity penalties in the changepoint estimation task, and thus, decide on an appropriate number of changepoints, a task which currently requires time-consuming parameter tuning by domain experts.

In this particular project, we seek a simple visualization interface to support, i) human labeling of the data with the aid of several complementary measures on the data-stream such as as mean, trends, min, max, variance, etc. and ii) interactive exploration of the result space suggested by a changepoint detection algorithm. Eventually, any visualization will help communicating the data and respective decisions.

The aim of this Infrastructure Project is to migrating all the third party libraries which oppia uses into their newer versions with no regressions, this will help oppia to solve some issue in the issue tracker whereas upgrade of few libraries will provide significant improvements in terms speed and user experience.

The VLC interface is quite outdated on Linux and Windows. It has a lot of features, but some are not properly exposed.

This project for the summer is to rework heavily this interface to make it beautiful and useful again.

This project aims at improving the LibreOffice's Online implementation over Android by adding new features to the document viewer, fixing the most annoying bugs and enhancing the overall UI/UX on the basis of design and performance.

Though the basic functionality of Bassa is complete and working, however AngularJS is not much supportive right now so the codebase needs to be shifted to a stable release. ReactJS with Webpack are to be used for creating the new codebase.

Improving VisualStates, a great tool for easily creating complex robot behaviour, by adding parameterisation to its automatas and an online automata library.

TensorMap is a project that will be a web application which will allow the users to create machine learning and deep learning algorithms visually. TensorMap will support reverse engineering of the visual layout to a Tensorflow implementation.

Boost uBLAS

Modifying (Smart) Expression Templates

Abstract

This proposal aims at improving the efficiency of the expression templates that are used by boost::numeric::ublas::tensor. Traditional Expression templates are efficient but Klaus Iglberger showed in his work that traditional ETs (Expression Templates) does not automatically result in faster execution of the expression. Smart expression templates are a tool for capturing the expression, possibly transforming and evaluating the expression. For better expression evaluation I will use Boost.YAP, a C++14 and later expression template library. Boost.YAP already offers a lot of functions and algorithms for dealing with expressions. It will ease my task moreover most of the issues pointed out in the paper cited above are efficiently handled by YAP. Hence, this proposal aims at the integration of Boost.YAP for convenient expression template transformation and evaluation in boost::numeric::ublas::tensor

Work on solving the issues and adding new functionalities

There is not yet any way in R to fully leverage the power of stochastic gradient algorithms for fitting generalized linear models (GLM). The overarching goal of this project is to develop the R package sgdnet into a mature state for the implementation of the efficient SAGA algorithm for elastic net-penalized GLMs, targeting the big data setting where observations greatly outnumber variables. It will result in a CRAN submission.

The goal of my project is to improve the existing Sugarizer-Server Dashboard. My proposed enhancements include:

• A profile for teachers.
• Extend Sugarizer-Server Analytics.
• Add Shell scripts.
• Improve code efficiency, application performance, and codebase structure.
• Extend the Sugarizer-Server Dashboard interface by improving UI:
  • Make the application UI fully responsive.
  • Add a feature to import and export the users and classroom data to CSV files.
  • Add an interactive (step by step) overlay tutorial.

Currently, Labplot has a basic set of measures for statistical analysis (Regressions, Histogram Plots, Location Measures, Dispersion Measures and Shape Measures). The idea is to add more statistical relevant features and also to generate some sort of report (using existing Worksheet widget) which shows all statistical analysis at one place (something like what is done in jasp), so that the statistician doesn’t need to add graphs and statistics measures manually and can easily analyse the data.

EOS delivers a set of icons that are made 1-to-1 following Material Design Icons. They are currently published at https://suse-uiux.gitlab.io/eos-icons/. The problem with this page is that it lacks engagement and information about the project: how to contribute new icons, how to submit icons request, how to install it, etc. On the other hand, EOS has a landing page that is more engaging, but there is a lot of useful information missing too. The EOS landing page could benefit from a section with a more automated way to scale the sub-pages and content with a CMS. Also, this project requires a web interface for EOS icons and EOS Design System, where both are aligned in terms of UX/UI and ideally can be managed with a headless CMS, such as Strapi [this is the currently used and preferred CMS at EOS]

VMAF is a new full-reference perceptual video quality metric developed by Netflix, which has a high correlation with subjective quality scores. This metric is widely used in industry, and I want to add VMAF plugin to GStreamer. Also, I have some additional interesting ideas related to VMAF accelerating and tuning.

QuTiP is best known for solving open quantum system dynamics. At the same time, it also has a Quantum Information Processing (QIP) submodule representing ideal quantum circuits. A tempting ideal to combine them is introducing random noise into the circuit by linking the circuit back to the Hamiltonian driving the evolution of the qubits. This could then be used to study the possible noise occurring in the experiments and how it will influence the result.

Lua, as a language, is made to function as a flexible scripting language to aid larger programs with minor tools that it can complete faster and easier than languages like C++ and Java could, but Lua lacks many of the core functions a scripting language is meant to have (i.e. file manipulation). Lua's light-weight nature is its strength, but programmers should be given a wide variety of options to enhance lua. Apolo is a library to add these core functions for projects that would require them to make full use of.

This project aims to get the GraphBLAS API working from Julia by connecting it to the SuiteSparse GraphBLAS implementation and creating a graph type backed by the methods provided in the library.

This project aims to develop a new fully-functional language server for D programming language using dmd library.

An app developed on Rocket.Chat App engine to integrate Google Calendar with Rocket.Chat. This can be used to create and view private and public calendar events.

The aim of this project is to bring SpaCy and Gensim functionality to Pharo. Along with that, I plan on integrating all the existing functioning NLP packages into a united library with a uniform API and good documentation.

Carrier synchronization in standard, mass-market GNSS receivers typically utilizes well understood locked-loop architectures. The performance obtained with such architectures is sufficient for benign propagation scenarios, but typically deliver poor performance under harsh propagation conditions. Code and carrier tracking, as well as joint code/carrier synchronization, can be formulated as an estimation problem which can be solved using Bayesian filtering methods. It has been shown in the GNSS literature that KF-based synchronization solutions can be used to overcome the performance limitations of standard approaches, offering implicitly adaptive filter bandwidth, and opening up the possibility of using nonlinear models to avoid certain limitations associated with the use of code, phase or frequency discriminators. In this contribution, we will leverage powerful nonlinear tracking algorithms, including cubature, unscented, and sigma point Kalman filters in order to produce realizations of carrier and joint code-carrier tracking blocks which promise to be more effective and adaptable in challenging GNSS environments when compared to traditional architectures.

I would like to work on issue #70, “OncoKB Analysis in Study View”. An inconvenience for both biologists trying to get valuable information to make informed decisions on prognosis and patients who would like to readily have access to this information for their own comfort, is the time needed to access this data. As the genomic data sets for each study vary in size, viewing annotations for studies that have large data sets in real-time is a challenge because it takes a while for the information to load. For example: MSK-IMPACT 2017 has a data set of 10,000 samples, so it will take a few minutes for the study view to load. I would like to work on the three backend tasks and first frontend task. This means pre-annotating the mutation data and storing it into the MySQL database and creating an additional column in the mutation table called “annotation”. Querying and using the web API to provide the information needed to solve the front-end goal of creating pie charts for oncogenicity and highest level of sensitive therapeutic implications per sample.

Bespoke Silicon group at University of Washington is working on the second version of their open source RISC-V manycore processor. They are also working on a CUDA-light programming environment using LLVM. This GSoC I plan to extend RV32 LLVM backend incorporating new hardware features.

When we are working with a dataset with geolocation, we need a tool to display it. The idea is build this tool. We will be able to upload the kml or json data, we are going to select the data type and which row will be the geolocation. We will be able to choose the legend and build new ones.

We plan to incorporate into bdvis two state-of-the-art elements: interactive plotting and dashboards. We plan to develop and test an interface that enables graphics interactivity with ‘drilling down’ capabilities.

Diagnostic visualization can unveil hidden patterns and anomalies in the data, and allow quick exploration of massive datasets. Developing novel interactive visualizations coupled with a modular dashboard system for biodiversity data, that can easily be employed by R experts and novices alike; will undoubtedly promote biodiversity research.

This project would add a feature on the rubygems.org website to give an option on each gem web page to show a tree/DAG of all transitive dependencies needed by that gem. In one of the issues that lead to this project, a user talks about how some users download a gem based of it’s transitive dependencies and how they need to keep a mindmap of these transitive dependencies to conclude whether or not to use the gem. This project will help such users get a better idea of whether that gem is for them or not.

The goal is to work on a GUI interface where the user can either type or paste in ASCII art for a Purr Data diagram and have it converted to a floating selection in the current Purr Data diagram. The ability for the user to type ASCII art into an object box that will be created and get converted into Pd diagram would be useful. This would let users paste ASCII art from the mailing list directly into the interface and make it easier for them to create Purr Data diagrams using only the keyboard. Also, the goal includes working on converting a subset of Purr Data diagrams into ASCII art after picking a subset of convertible Pd diagrams to ASCII art from the text archives of the Pd mailing list that can be parsed.

Eclipse CBI is currently in the process of migrating all the Jenkins instances it manages to a Kubernetes (OpenShift) cluster. The goal of this topic is to implement a dashboard listing all Jenkins instances running in the Kubernetes cluster but with live data from the cluster such as pod status, resource usage, Jenkins queue size etc.

The Genomic Data Commons (GDC) Portal serves as a large-scale genomic data repository hosting data from NCI cancer genome projects in standardized formats amenable to programmatic access. As one of the major goals of the cBioPortal is to serve cancer genomic data from a wide range of sources in a easy to analyze manner, the creation of an Extraction Translation (ET) pipeline between the two platforms would greatly benefit the cancer genomic research community as a whole.

A previous GSOC project laid the foundation for this pipeline, developing a Spring Batch pipeline that takes a GDC manifest file specifying the data desired and creates a clinical file and a Genome Nexus annotated MAF suitable for cBioPortal import. This project will expand on the pipeline, creating new Spring Batch reader/processor/writers and corresponding pipeline logic for CNA and mRNA expression data, two data types similar in format and useful in conjunction to analyze over and under expressed genes in a given sample.

We all know that large data set is crucial for good performance models and we have millions of parameters that need to be trained.. My proposal is to add data augmentation module to opencv similar to the ones in other libraries like keras for example.

This project involves building a webapp to replace the current user onboarding flow for centos.ci.org

There are works dedicated toward Optical Character Recognition (OCR) for images, but there has not been a robust pipeline aiming to generate OCR for video recordings not only for English but also for other languages. Combining with some state-of-the-art detection technique and OCR tools, I propose a pipeline that can potentially detect and recognize texts appearing in International Television News, using Mask R-CNN and ShueNet, with the auxiliary of ASR.

Integration of ActionCable to implement web Sockets for Various Real-Time communication in the plots2 project such as for Notification, Comments etc.

Sensor Data and Upload Library project for making a reusable package that can be used independently to convert and analyse CSV data into Graphs or Charts.

I propose to improve the installation experience of Amahi by completely removing the method of INSTALL CODE and setting up basic Amahi HDA without an API key. And then work on Home Automation stuffs and try to integrate well with Amahi. The problem is that right now, Amahi can’t be used without registration. So, those who want to try out Amahi without registration, can’t do so. So, we may be losing a few users who don’t like some hassle of registration So, I will change the code of hda-ctl and hda-install so that basic Amahi hda can be set up. Then I will change the Anaconda Module accordingly. Then I will work on creating a package for Home Automation stuffs and integrate it with some extent to Amahi. Since, I have worked with Amahi before, especially with installing and setting up Amahi division. I have deep knowledge of how Amahi gets set up and runs in the background with hda-ctl. So, I have deep knowledge of code for hda-ctl repo. I have done extensive app testing in my previous GSoC so, I have some knowledge of Amahi Apps.

Reinforcement learning is a class of machine learning methods that use the reward signal of the environment to infer optimal actions. Thus, easy environments for reinforcement learning agents are those with dense reward signals. In these environments, most algorithms included in TF-Agents already achieve good results. However, in sparse-reward environments such as Montezuma’s Revenge from Atari 2600, such algorithms fail to discover optimal behavior as it rarely finds any nonzero reward. To mitigate this problem, multiple methods have been proposed to add intrinsic rewards or “curiosity” to existing algorithms to extend the capability of these algorithms.

This project will implement three curiosity modules to TF-Agents: pseudocount-based exploration via Context Tree Switching (CTS), Intrinsic Curiosity Module (ICM), and Random Network Distillation (RND). These modules will be implemented as modules so that they can be enabled or disabled in one line for existing reinforcement learning algorithms in TF-Agents. With the addition of these modules, the users will be able to gain meaningful results without careful reward shaping on sparse-reward environments.

This project includes adding BLAS, Sparse linear algebra and iterative solvers into Chapel.

Eclipse SWTChart allows to create different types of charts. The API is well designed and allows to create Line, Bar and Scatter charts easily. In addition to that, charts can be created even more easily with the SWTChart extensions. It uses the convention over configuration pattern and offers many additional improvements to scale axes of different type automatically or to select specific data ranges.

This project aims to extend the export options already available under the SWTChart extensions menu. Currently available export options are PNG, JPG, BMP, CSV, LaTeX, R Script.

New export options to be added are .PDF (Portable Document Format) .SVG (Scalable Vector Graphics) .EPS (Encapsulated PostScript)

Communication using body language is an ancient art form, currently evolving in many fascinating ways. And automatic detection of human body language is becoming an active subject of research due to its application in various vision-based articulated body pose estimation systems such as Markerless motion capture for human-computer interfaces, Robot control, visual surveillance, Human image synthesis. A specific part of this field, gesture recognition, has gained great attention in recent years. Current focuses in the field include emotion recognition from face and hand gesture recognition.

This project proposes an automated system for hand gesture detection and recognition in TV news videos. Given a news video of certain time duration, the automated system will not only detect the hand gestures in the video but also provide a label from among the set of hand-gesture classes. Finally, incorporate the system into singularity container for deployment on high-performance clusters (HPC) clusters.

scipy.fftpack provides several variants of fast fourier transforms for use in numerical and scientific computing applications. Currently this a python wrapper around it’s namesake, the fortran fftpack library. However, a number of concerns exist about the precision and performance of the current fft implementations. Thus, it is desirable to allow 3rd party libraries to be used instead of fftpack, allowing for improved performance and accuracy.

This project would first design and implement a backend interface which will allow different libraries to be called underneath the scipy.fftpack interface. Then a selection of 3rd party fft libraries can be adapted to implement this interface and provide users with a range of backends to choose from. These backends may be selected at runtime to accelerate existing users of the scipy.fftpack interface without any changes to their code.

Graal produces analysis related to code complexity, quality, dependencies, vulnerability and licensing and the data produced conforms to the ones that can be processed by GrimoireLab. I will mainly be focusing on:

• Adding support of source code related metrics to Grimoirelab with the help of analysis data produced by Graal.
• Adapting Grimoirelab toolchain to be able to execute Graal and process the data produced by it.
• Writing appropriate unit tests for additional backends, their corresponding supporting connectors, and methods.
• Producing analytics related to proposed and calculated metrics* ( described below )
• Adding documentation related to additional features and improvements in existing ones.

Out of all the five backends provided by Graal, CoCom (Code Complexity) covers a vast majority of the popular languages and CoLic (Code License) supported by NOMOS & ScanCode helps us fetch license & copyright related information from software development repositories and is language independent. Addition of metrics related to these two backends during GSoC period could be applied to a wide range of projects in the future.

I would be working on the following features, and some additional features which are mentioned in my proposal based on Community remarks,

1) Add Multiple account login and maintain session of the account.

2) Add Passcode feature to avoid the everytime login.

3) Sync Adapter to sync clients and client data that is assigned to him.

4) Add Kotlin support in app and initially change the retrofit models in kotlin.

5) Add review screen in every new records creation form.

6) Edit Loan application feature if loan is not approved

7) Add new data views in different different pages like customer detail page according to API, same as in loan, deposit account details

This project aims to create a Graphical User Interface (GUI) for big gridded geospatial data visualization in the browser interface backed by the full power of the Python ecosystem. This GUI would allow controlled data points selection, massive rendering, data display, custom interaction, selection of fields for plotting and layout of widgets in the browser using Intake, Xarray and Pyviz collection of tools. Currently majority of geospatial data exploration happens in stand-alone applications like Panoply and NcView, tools that have limited functionality, do not provide complex analysis methods and can only be reasonably extended by the software developers on those projects. This new tool, written in Python, but presented as a dashboard in the notebook environment, will be extendable directly by researchers by using it in conjunction with tools like Dask and will also provide complex analysis methods on the data being visualized. It holds the promise of saving Earth Science and other researchers significant amounts of time since they can directly focus on visual data analysis and research rather than writing custom code to explore data.

In this project I am going to create a new language pair Uzbek-Karakalpak. Because, There is no other single translator between these two languages despite their similarities. Also, this project would open new ways for Karakalpak language to connect with other languages as well. In addition I have made the project (https://play.google.com/store/apps/details?id=com.shagalalab.sozlik): Russian -> Karakalpak and Karakalpak->English dictionary, therefore I have an access to the biggest Karakalpak language dictionary which I am going to use it here. So I believe that I can easily make a transducer for Karakalpak language.

Using Django To Create GUI For Input Error Visualizationa and Correction

In recent years, ns-3 has been widely used for the simulation of wireless networks, because it features several built-in and external modules implementing different wireless technologies. The overall performance of this kind of networks are strongly influenced by the characteristics of the signal propagation through the wireless link, thereby, a proper modeling of the channel behavior is of primary importance to obtain reliable results from the simulations. This project aims to tackle this issue by proposing an extension of the spectrum module to model both frequency and spatial-dependent phenomena, and to account for the directional behavior of the signal propagation. This will be achieved by implementing the modeling framework described in 3GPP TR 38.901, which includes the statistical characterization of different propagation environments, supports the modeling of multi-antenna systems, and, thanks to its modularity, can be easily extended with new environments or other additional features. Even if it has been specifically designed for the simulation of cellular networks, it supports frequency bands between 0.5 and 100 GHz, thus can be used even for other wireless technologies.

ipptool is used for development and debugging of IPP-related software and for PWG self-certification for IPP Everywhere printers for driverless printing. I am to develop additional ipptool test scripts for all new operations, objects, attributes defined in IPP System Service v1.0

Audio Worklet, an extension to the Web Audio API currently available in Google Chrome, allows developers to write their own AudioWorkletNodes that will run audio processing code on a separate thread. This replaces the deprecated, less efficient ScriptProcessorNode, which runs on the main UI thread.

For this project, I will replace all instances of ScriptProcessorNode in p5.Sound with AudioWorklet, with a polyfill for browsers that don’t yet support AudioWorklet. This will improve the efficiency of the p5.SoundRecorder and p5.Amplitude nodes, and possibly also p5.SoundFile.

This project revolves around making the xapian-letor and xapian-evaluation module releasable. It includes writing extensive tests for various High-level API's and low-level pieces, the addition of new rankers and scorer metrics and adding binding support for letor module in various languages.

GNSS Reflectometry (GNSS-R) is the application of GNSS signals to determine geophysical parameters of the Earth’s surface, as well as the atmospheric layer. The idea is to jointly exploit the direct and reflected GNSS signals. These reflected signals are particularly interesting on water or ice surfaces. The receiver can be located at all altitudes: from the ground to low Earth orbit (LEO) satellites. Two major types of measurements can be made: i) relative power measurements between direct and reflected signals from which we can derive, for instance, the surface roughness, and by extension the surface wind (this is the mission CYGNSS), and ii) measurements of relative delay between direct and reflected signals.

Rubyplot only supports GR back-end, my project is to extend this support to Magick back-end, adding plot function to Rubyplot and integration with iruby notebooks. This project will greatly enhance the plotting interface of Rubyplot and pave the way for much greater expansion and allow users to test and debug their code easily.

In this project, I propose to add Recurrent Neural Networks to ChainerX. RNNs are a very integral part of deep learning research. ChainerX is faster as compared to other frameworks (eg: Chainer, PyTorch) since its core code is completely implemented in C++. It currently lacks implementations of RNNs. In this project, I will provide C++ implementations of RNN models (LSTM, GRU). This will bring the fast speed of ChainerX to RNN models. I aim to replicate all RNN-related chainer ops in ChainerX. I will also provide sufficient code examples on how to use the RNN models of ChainerX.

In this project, my work will mainly focus on working as a full stack developer for Amahi. I will work on to implement new features and functionalities for Amahi 12. I will improve front end of the platform using the latest javascript and jquery functions, develop new plugins and implement new features for it. Last summer, I have implemented most of the parts of friending plugin. I will implement the remaining parts of this plugin, test it and make it work for the production and release it for the latest version of Amahi. I would also like to work on docker related stuff. New docker version has many great features, that seems to be super useful for current docker-compose implementation. I will also implement new plugins for Amahi 12.

This project will aim to create a pipeline for all CPTAC data transformation into cBioPortal compatible files for public access. Conversion and addition of novel CPTAC proteogenomic datasets into the cBioPortal will advance cancer studies, which will lead to a better understanding of the molecular profiles of cancer.

GraphicsFuzz is a tool that helps graphics driver makers capture defects by fuzzing and rendering semantically equivalent shaders. The tool applies the metamorphic testing technique that transforms shaders using the available functions in OpenGL shading language (GLSL). Currently, GLSL built-in functions are not fully supported by the tool. Providing a new set of GLSL features to GraphicsFuzz would create new ideas of transformation, and help the tool to detect a wider range of bugs.

This project aims to achieve a better ecosystem for Images.jl, an image-processing toolbox in Julia. Main contributions consist of user-friendly documentation on Images.jl ecosystem, developer manual, and more consistent, robust, and extensible APIs. Moreover, this project also serves as a subproject to bring Images.jl from pre-Julia-1.0 stage to post-Julia-1.0 stage, and eventually to Images.jl v1.0 milestone.

To develop official helm chart of xwiki so that it can be seamlessly deployed to Kubernetes. The chart should be configurable and highly available.

coala currently has few generic bears which are not very maintained. This project revolves around the objective of getting most generic bears in a working state so that they can be used in production.

Apart from the current bear, this project brings many new generic bears which have been requested by the community from a long time but they were not worked upon. Such bears include OutdatedDependencyBear, FileModeBear, FileExistsBear, RequirementsCheckBear, etc. Apart from these, there are several improvements to PEP8Bear and PycodestyleBear. All of the bears are well tested and documented. This project also brings a few improvements to coala core and upstream repositories.

Amahi-Anywhere file server is complete and working as of now, but there can be certain improvements that can be done to so as to improve both, the code base as well as user experience. This proposal focuses on the implementation of those improvements and optimizations. Improvements in logging system will help the developers to get a better knowledge of the events happening in the system. The addition of a good caching mechanism will ultimately lead to a reduction of latency by a huge factor and thus will greatly enhance user experience.

This project also focuses on the implementation of some features which in turn will make the management of the Amahi app easier with the help of special dashboards where users can easily monitor the system and take action accordingly.

Commission and curate new examples for http://p5js.org/ on the occasion of the upcoming 1.0 release to showcase the power of community and collaboration in open source and creativity on the web. Examples co-created by people across disciplines and experience levels to demonstrate collaborative and inclusive practices of building software (i.e., pair programming using the new p5.js Web Editor) are especially encouraged.

Implementing gearwork and communication interface for the USB 3.0 plugin module, designed by apertus° Association, for streaming live 4K 12-bit video data above 25 FPS through a USB 3.0 interface to a connected PC.

This project will improve the GitBook of syslog-ng by adding a chapter for plugin programming, with sections dedicated to the various types of plugins found in syslog-ng. A non-trivial example plugin will accompany each section, to aid in the explanation.

This project will add the capacity for Perl 6 to produce and execute self-contained binaries on Windows, Linux, and MacOS. I will start with an executable binary for a basic Hello World program, and incrementally add support for linking to shared system and user libraries. Time permitting, I will work with my mentors to enable support and/or work arounds to enable linking to C and other languages.

My approach will be similar to how the .NET Core creates self-contained and framework dependent deployment binaries. I have chosen this as a model as it has proven capable of running on Linux, Windows, and MacOS systems. While my work may focus initially on either Windows and the Portable Executable (PE) or Linux and Executable and Linkable Format (ELF), this approach will hopefully ensure a path forward that will eventually be capable of producing executable binaries on all popular modern operating systems.

The basic method which the .NET Core uses to create executable binaries is by creating a manifest of information in the operating system dependent executable binary format which is linked to .NET’s runtime library, and handed to a .NET “main” function which executes the user program.

The project will aim to enhance the existing annotation capability and add another type of annotations like dimensions , labels and single or multiple lines notes the idea is to make all kinds of annotation share the same logic in entering the properties of annotation and the graphical representations and taking advantage of the existing primitives like lines and fonts to represent the annotation this will help to exploit the existing capabilities of these primitives like rotation and positioning .

Nuitka is a Python compiler written in Python. It is a seamless replacement or extension to the Python interpreter and compiles every construct that CPython does. Nuitka works by translating Python code into a C level program which can be executed in the same way as CPython using libpython and a few C files of its own. All optimizations of Nuitka are aimed at improving performance while ensuring perfect compatibility. This project ensures Nuitka’s compatibility with the top 50 PyPI packages by setting up automated testing for each package. These automated tests will serve to be very important tools for the development of Nuitka, as they will be used to assure Nuitka’s compatibility with the most used Python packages every time Nuitka receives a new update.

As part of GSOC 2018, a Password Reset project was initiated which was meant to revolutionize the way password resets were handled in OpenMRS. It was completed successfully, with extensive work done in the backend. But there is no accompanying user interface for that, thus the goal of this project is to serve as a continuation of the corresponding GSOC 2018 Project, to build a user interface for the Password Reset mechanism, and also to introduce some security measures like CAPTCHA, location identification and some other things, into the current Password Reset Scheme.

NVDA provides support for the Windows command console used by Command Prompt, PowerShell, and the Windows Subsystem for Linux. It allows users to read the console's contents using review cursor commands, and automatically reports console output as it arrives. While functional, this support has some shortcomings, leading to decreased NVDA performance and stability and, by extension, user productivity. This proposal seeks to take advantage of changes to the command console introduced in the Windows 10 Fall Creators Update and refined in later releases, leading to an improved console experience for users on current Windows versions.

qual.net’s Rust rewrite will enable improved modularity, performance, and security, but rewriting an entire system in a new and rapidly evolving language is a difficult task. A network simulator able to mock out the entire world of devices and connections on which qual.net will have to operate is an important step in ensuring functionality is implemented as intended.

This project will result in a working MVP of a dual layer network simulator. This simulator will provide hooks for the netlink and HTTP API levels, into which tests can inject behavior and from which metrics and test results can be extracted.

LLVM functions can be tagged with several attributes. These attributes are used in optimizations to decide whether a particular transformation is valid or not. Functions attributes can be either given by the frontend or be inferred by LLVM. There are some attributes which can not be inferred now. If we could infer them, more optimization would be done. In addition to this, there are a lot of problems in current implementation. First of all, each algorithm is very similar but implemented separately. If we extend these implementations to infer other attributes, there would be a lot of code duplication and it is hard to maintain consistency. Therefore, it is better to replace them with a more designed implementation. We have a new framework for deducing attribute called “Attributor” developed by Johannes Doerfert. So I propose to extend this framework and deduce attributes.

This project aims to build an elaborate multimodal emotion recognition system inside a Singularity container. I will train a state-of-the-art audio-visual emotion recognition model on different datasets. In the proposed system, speech and video data are processed by two convolutional neural networks (CNNs). The outputs of the two CNNs are then fused using two consecutive extreme learning machines (ELMs). The output of the fusion is given to a support vector machine (SVM) for final classification of the emotions. I will use UCLA’s NewsScape dataset with ground truth annotations to evaluate the system. The system will be eventually incorporated into the Red Hen pipeline at CWRU HPC so that it can be used to recognize emotions in user-specified videos.

Clad is a C++ Clang compiler plugin that employs automatic differentiation to derive user-defined functions, performing source code transformations so that users do not have to conform to custom types to comply with external libraries.

With the integration of clad::gradient to CLAD, a reverse accumulation method for automatic differentiation was introduced. Now, it makes sense to move on to second partial derivatives, in particular, to calculating the Hessian matrix. My work is to build on the existing framework that uses Clang AST to do source transformations on functions, and to implement an efficient Hessian calculation method that extends the capabilities of CLAD using the edge pushing algorithm and Hessian reverse accumulation method. I will also try to extend existing CLAD functions to calculate the Jacobian matrix.

CGAL provides now basic viewers, i.e. global functions allowing to visualize in 3D some CGAL data-structures. These small viewers are very usefull in order to visualize the result of an algorithm, and can help to debug some code. For now, 5 basic viewers exist, for Polyhedron, Surface_mesh, Triangulation_2, Triangulation_3 and Linear_cell_complex. The goal of this project is to develop more basic viewers for other CGAL data-structures.